/*
	Functions.c
	--------------------------------------------------
	Squirrel function wrappers.
*/

#include "Functions.h"
#include "SQModule.h"
#include "SQMain.h"
#include "SquirrelUtils.h"
#include <squirrel.h>

extern HSQUIRRELVM v;
extern SQAPI sq;
extern SQCLASSES sq_classes;

void Print( const char* message )
{
	SQInteger stack = sq->gettop( v ); // Get the current stack size (so that we can restore it after the call)

	sq->pushroottable( v );
	sq->pushstring( v, _SC( "print" ), -1 );
	sq->get( v, -2 ); // Get the function 'print' from the root table
	sq->pushroottable( v ); // 'this' (function environment object)
	sq->pushstring( v, message, -1 );
	sq->call( v, 2, SQFalse, SQFalse ); // Push arguments to the stack and call the function
	sq->settop( v, stack ); // Return the old stack
}

void Message( const char* message, Colour col )
{
	SQInteger stack = sq->gettop( v );

	sq->pushroottable( v );
	sq->pushstring( v, _SC( "Message" ), -1 );
	sq->get( v, -2 );
	sq->pushroottable( v );
	sq->pushstring( v, (const SQChar*)message, -1 );
	sq->pushinteger( v, (SQInteger)col.r );
	sq->pushinteger( v, (SQInteger)col.g );
	sq->pushinteger( v, (SQInteger)col.b );
	sq->call( v, 5, SQFalse, SQFalse );
	sq->settop( v, stack );
}

void MessagePlayer( const char* message, Player player, Colour col )
{
	SQInteger stack = sq->gettop( v );

	sq->pushroottable( v );
	sq->pushstring( v, _SC( "MessagePlayer" ), -1 );
	sq->get( v, -2 );
	sq->pushroottable( v );
	sq->pushstring( v, (const SQChar*)message, -1 );
	sq_pushplayerpointer( v, player );
	sq->pushinteger( v, (SQInteger)col.r );
	sq->pushinteger( v, (SQInteger)col.g );
	sq->pushinteger( v, (SQInteger)col.b );
	sq->call( v, 6, SQFalse, SQFalse );
	sq->settop( v, stack );
}

void MessageAllExcept( const char* message, Player player, Colour col )
{
	SQInteger stack = sq->gettop( v );

	sq->pushroottable( v );
	sq->pushstring( v, _SC( "MessageAllExcept" ), -1 );
	sq->get( v, -2 );
	sq->pushroottable( v );
	sq->pushstring( v, (const SQChar*)message, -1 );
	sq_pushplayerpointer( v, player );
	sq->pushinteger( v, (SQInteger)col.r );
	sq->pushinteger( v, (SQInteger)col.g );
	sq->pushinteger( v, (SQInteger)col.b );
	sq->call( v, 6, SQFalse, SQFalse );
	sq->settop( v, stack );
}

void GetPlayerID( Player player, int* id )
{
	SQInteger stack = sq->gettop( v );
	SQInteger rtn = 0;
	
	sq_pushplayerpointer( v, player );
	sq->pushstring( v, _SC( "ID" ), -1 );
	sq->get( v, -2 );
	sq->getinteger( v, -1, &rtn );
	sq->settop( v, stack );

	*id = (unsigned char)rtn;
}

void GetPlayerName( Player player, char* name )
{
	SQInteger stack = sq->gettop( v );
	const SQChar* rtn = NULL;

	sq_pushplayerpointer( v, player );
	sq->pushstring( v, _SC( "Name" ), -1 );
	sq->get( v, -2 );
	sq->getstring( v, -1, &rtn );
	sq->settop( v, stack );

	strcpy( name, rtn );
}

void GetPlayerIP( Player player, char* ip )
{
	SQInteger stack = sq->gettop( v );
	const SQChar* rtn = NULL;

	sq_pushplayerpointer( v, player );
	sq->pushstring( v, _SC( "IP" ), -1 );
	sq->get( v, -2 );
	sq->getstring( v, -1, &rtn );
	sq->settop( v, stack );

	strcpy( ip, rtn );
}

void GetPlayerHealth( Player player, float* health )
{
	SQInteger stack = sq->gettop( v );
	SQInteger rtn = 0;

	sq_pushplayerpointer( v, player );
	sq->pushstring( v, _SC( "Health" ), -1 );
	sq->get( v, -2 );
	sq->getinteger( v, -1, &rtn );
	sq->settop( v, stack );

	*health = (float)rtn;
}

void SetPlayerHealth( Player player, float health )
{
	SQInteger stack = sq->gettop( v );
	
	sq_pushplayerpointer( v, player );
	sq->pushstring( v, _SC( "Health" ), -1 );
	sq->pushinteger( v, (SQInteger)health );
	sq->set( v, -3 );
	sq->settop( v, stack );
}

void GetPlayerPos( Player player, Vector3* pos )
{
	SQInteger stack = sq->gettop( v );
	SQUserPointer rtn = NULL;
	Vector3 vec;

	sq_pushplayerpointer( v, player );
	sq->pushstring( v, _SC( "Pos" ), -1 );
	sq->get( v, -2 );
	sq->getinstanceup( v, -1, &rtn, sq_classes->Vector );

	if ( !rtn ) { sq->settop( v, stack ); return; }

	vec = *(Vector3*)rtn;
	pos->x = vec.x;
	pos->y = vec.y;
	pos->z = vec.z;

	sq->settop( v, stack );
}

void SetPlayerPos( Player player, Vector3* pos )
{
	SQInteger stack = sq->gettop( v );

	sq_pushplayerpointer( v, player );
	sq->pushstring( v, _SC( "Pos" ), -1 );
	sq_pushvector3pointer( v, pos );
	sq->set( v, -3 );
	sq->settop( v, stack );
}

void GetBlipDisplayType( Blip blip, int* displayType )
{
}

void SetBlipDisplayType( Blip blip, int displayType )
{
}

void GetBlipColour( Blip blip, Colour* colour )
{
}

void SetBlipColour( Blip blip, Colour colour )
{
}

void GetBlipIcon( Blip blip, int* sprite )
{
}

void SetBlipIcon( Blip blip, int sprite )
{
}

void GetBlipID( Blip blip, int* id )
{
}

void GetBlipOwner( Blip blip, Player* player )
{
}

void GetBlipPos( Blip blip, Vector3* pos )
{
}

void SetBlipPos( Blip blip, Vector3* pos )
{
}

void GetBlipSize( Blip blip, int* size )
{
}

void SetBlipSize( Blip blip, int size )
{
}

void RemoveBlip( Blip blip )
{
}

void CreateBlip( int sprite, Vector3* pos, Blip* blipRet )
{
}

void CreateClientBlip( Player player, int sprite, Vector3* pos, Blip* blipRet )
{
}

void FindBlip( int id, Blip* blipRet )
{
}

void FindClientBlip( int id, Player player, Blip* blipRet )
{
}

void GetBlipCount( int* blipCount )
{
}

void GetClientBlipCount( Player player, int* blipCount )
{
}

void FadeCamera( Player player, float speed, int fadeIn, Colour col )
{
}

void GetCinematicBorder( int* isEnabled )
{
}

void GetPlayerCinematicBorder( Player player, int* isEnabled )
{
}

void RestoreCamera( Player player )
{
}

void ShakeCamera( Player player, int intensity )
{
}

void SetCameraMatrix( Player player, Vector3* pos, Vector3* look, Vector3* rotation )
{
}

void SetCinematicBorder( int enabled )
{
}

void SetPlayerCinematicBorder( Player player, int enabled )
{
}

void GetFlyingCars( int* isEnabled )
{
}

void GetPlayerFlyingCars( Player plr, int* isEnabled )
{
}

void GetHandlingCheat( int* isEnabled )
{
}

void GetPlayerHandlingCheat( Player plr, int* isEnabled )
{
}

void SetFlyingCars( int enabled )
{
}

void SetPlayerFlyingCars( Player plr, int enabled )
{
}

void SetHandlingCheat( int enabled )
{
}

void SetPlayerHandlingCheat( Player plr, int enabled )
{
}

void CreateCheckpoint( Vector3* pos, float radius, Colour col, Checkpoint* checkpointRet )
{
}

void CreateClientCheckpoint( Vector3* pos, float radius, Colour col, Player plr, Checkpoint* checkpointRet )
{
}

void GetCheckpointColour( Checkpoint checkpoint, Colour* col )
{
}

void SetCheckpointColour( Checkpoint checkpoint, Colour col )
{
}

void GetCheckpointID( Checkpoint checkpoint, int* id )
{
}

void GetCheckpointOwner( Checkpoint checkpoint, Player* plr )
{
}

void GetCheckpointPos( Checkpoint checkpoint, Vector3* posRet )
{
}

void SetCheckpointPos( Checkpoint checkpoint, Vector3* pos )
{
}

void GetCheckpointRadius( Checkpoint checkpoint, float* radiusRet )
{
}

void SetCheckpointRadius( Checkpoint checkpoint, float radius )
{
}

void RemoveCheckpoint( Checkpoint checkpoint )
{
}

void GetCheckpointType( Checkpoint checkpoint, int* typeRet )
{
}

void SetCheckpointType( Checkpoint checkpoint, int typeRet )
{
}

void GetCheckpointVirtualWorld( Checkpoint checkpoint, int* worldRet )
{
}

void SetCheckpointVirtualWorld( Checkpoint checkpoint, int world )
{
}

void FindCheckpoint( int id, Checkpoint* checkpointRet )
{
}

void FindPlayerCheckpoint( int id, Player player, Checkpoint* checkpointRet )
{
}

void GetCheckpointCount( int* countRet )
{
}

void GetPlayerCheckpointCount( Player player, int* checkpointRet )
{
}

void CreateExplosion( Vector3* pos, int explosionType )
{
}

void CreateFire( Vector3* pos, float radius )
{
}

void ExtinguishFire( Vector3* pos, float radius )
{
}

void ExtinguishAllFires( )
{
}

void CloseGarage( int garage )
{
}

void CloseSSVBridge( int delayed )
{
}

void EnableTrains( int enabled )
{
}

void GetBoundariesLower( Vector3* vectorRet )
{
}

void GetBoundariesUpper( Vector3* vectorRet )
{
}

void GetFriendlyFire( int* isEnabled )
{
}

void GetGamespeed( float* speed )
{
}

void GetGravity( float* gravity )
{
}

void GetHour( int* hour )
{
}

void GetIslands( int* islands )
{
}

void GetMinute( int* minute )
{
}

void GetSSVBridgeLock( int* isLocked )
{
}

void GetSSVBridgeUpdateTime( int* updateTime )
{
}

void GetSurfaceTraction( int surface, float* traction )
{
}

void GetTimeLock( int* isLocked )
{
}

void GetWeather( int* weather )
{
}

void GetWeatherLock( int* isLocked )
{
}

void IsSSVBridgeUp( int* isBridgeUp )
{
}

void OpenGarage( int garage )
{
}

void OpenSSVBridge( )
{
}

void SetBoundaries( Vector3* upper, Vector3* lower )
{
}

void SetFriendlyFire( int enabled )
{
}

void SetGamespeed( float speed )
{
}

void SetGravity( float gravity )
{
}

void SetIslands( int islands )
{
}

void SetSSVBridgeLock( int locked )
{
}

void SetSSVBridgeUpdateTime( int timeInSecs )
{
}

void SetSurfaceTraction( int surface, float value )
{
}

void SetTime( int hour, int min )
{
}

void SetTimeLock( int locked )
{
}

void SetWeather( int weatherID )
{
}

void SetWeatherLock( int locked )
{
}

void BigMessage( const char* text, int timeInMS, int type )
{
}

void BigMessageForPlayer( Player player, const char* text, int timeInMS, int type )
{
}

void ClearMessages( )
{
}

void ClearMessagesForPlayer( Player plr )
{
}

void PagerMessage( const char* text, int speed, int unknown, int sound )
{
}

void PagerMessageForPlayer( Player plr, const char* text, int speed, int unknown, int sound )
{
}

void SendPlayerMessage( Player faking, Player recipient, const char* text )
{
}

void SmallMessage( const char* text, int timeInMS, int type )
{
}

void SmallMessageForPlayer( Player plr, const char* text, int timeInMS, int type )
{
}

void BanIP( const char* IP )
{
}

void BanPlayer( Player plr )
{
}

void GetBodyPartName( int bodyPart )
{
}

void GetDistrictName( float x, float y )
{
}

void KickPlayer( Player plr )
{
}

void UnbanIP( const char* IP )
{
}

void CreateObject( int model, Vector3* pos )
{
}

void FindObject( int id )
{
}

void GetObjectCount( )
{
}

void GetObjectAngle( Object object, Vector3* rot )
{
}

void SetObjectAngle( Object object, Vector3* rot )
{
}

void GetObjectID( Object object, int* idRet )
{
}

void GetObjectModel( Object object, int* modelRet )
{
}

void MoveObjectTo( Object object, Vector3* pos, float speed )
{
}

void GetObjectPos( Object object, Vector3* pos )
{
}

void SetObjectPos( Object object, Vector3* pos )
{
}

void RemoveObject( Object object )
{
}

void RotateObjectTo( Object object, Vector3* angle, float speed )
{
}

void StopObject( Object object, int movement, int rotation )
{
}

void GetObjectVirtualWorld( Object object, int* vWorld )
{
}

void SetObjectVirtualWorld( Object object, int vWorld )
{
}

void CreatePickup( int model, Vector3* vector, Pickup* pickupRet )
{
}

void FindPickup( int id, Pickup* pickupRet )
{
}

void GetPickupCount( int* countRet )
{
}

void GetPickupID( Pickup pickup, int* idRet )
{
}

void GetPickupInstantRespawn( Pickup pickup, int* isTrue )
{
}

void SetPickupInstantRespawn( Pickup pickup, int isTrue )
{
}

void GetPickupModel( Pickup pickup, int* idRet )
{
}

void GetPickupOneTime( Pickup pickup, int* isOneTime )
{
}

void SetPickupOneTime( Pickup pickup, int isOneTime )
{
}

void GetPickupPos( Pickup pickup, Vector3* posRet )
{
}

void SetPickupPos( Pickup pickup, Vector3* pos )
{
}

void RemovePickup( Pickup pickup )
{
}

void RespawnPickup( Pickup pickup )
{
}

void FindPlayer( int id, Player* playerRet )
{
}

void FindPlayerByName( const char * name, Player* playerRet )
{
}

void GetClosestPlayer( Player player, Player* playerRet )
{
}

void GetPlayerAlpha( Player player, int* alphaRet )
{
}

void SetPlayerAlpha( Player player, int alpha )
{
}

void GetPlayerAngle( Player player, float* angleRet )
{
}

void SetPlayerAngle( Player player, float angle )
{
}

void GetPlayerArmour( Player player, int* armourRet )
{
}

void SetPlayerArmour( Player player, int armour )
{
}

void GetPlayerCash( Player player, int* cashRet )
{
}

void SetPlayerCash( Player player, int cash )
{
}

void GetPlayerClass( Player player, int* classRet )
{
}

void SetPlayerClass( Player player, int classId )
{
}

void ClearPlayerWeapons( Player player )
{
}

void GetPlayerColour( Player player, int* colourRet )
{
}

void SetPlayerColour( Player player, int colour )
{
}

void GetPlayerColouredName( Player player, char * colouredName )
{
}

void SetPlayerColouredName( Player player, char * colouredName )
{
}

void ForcePlayerEnterVehicle( Player player, Vehicle vehicle, int door )
{
}

void ForcePlayerExitVehicle( Player player )
{
}

void ForcePlayerSpawnScreen( Player player )
{
}

void GetPlayerFrozen( Player player, int* ret )
{
}

void FreezePlayer( Player player )
{
}

void UnfreezePlayer( Player player )
{
}

void GetPlayerLowerBoundaries( Player player, Vector3* posRet )
{
}

void GetPlayerUpperBoundaries( Player player, Vector3* posRet )
{
}

void GetPlayerIgnoringPlayer( Player player, Player ignorance, int* ignoring )
{
}

void GetPlayerImmune( Player player, int* isImmune )
{
}

void SetPlayerImmune( Player player, int immune )
{
}

void GetPlayerIsland( Player player, int* islandRet )
{
}

void GetPlayerMarker( Player player, int* isVisible )
{
}

void SetPlayerMarker( Player player, int visible )
{
}

void GetPlayerMuted( Player player, int* isMuted )
{
}

void SetPlayerMuted( Player player, int muted )
{
}

void GetPlayerNametag( Player player, int* isVisible )
{
}

void SetPlayerNametag( Player player, int visible )
{
}

void GetPlayerPing( Player player, int* ping )
{
}

void RemovePlayerFromVehicle( Player player )
{
}

void RemovePlayerLimb( Player player, int limb )
{
}

void SetPlayerScore( Player player, int score )
{
}

void GetPlayerScore( Player player, int* score )
{
}

void SetPlayerAnim( Player player, int anim )
{
}

void SetPlayerBoundaries( Player player, Vector3* lowerBounds, Vector3* upperBounds )
{
}

void SetPlayerVehicleEnterDoor( Player player, int door )
{
}

void SetPlayerWeapon( Player player, int weapon, int ammo )
{
}

void GetPlayerSkin( Player player, int* weapon )
{
}

void SetPlayerSkin( Player player, int weapon )
{
}

void ForcePlayerSpawn( Player player )
{
}

void ForcePlayerSpawnWithClass( Player player, SpawnClass classType )
{
}

void GetPlayerSpawned( Player player, int* isSpawned )
{
}

void GetPlayerTeam( Player player, int* teamRet )
{
}

void SetPlayerTeam( Player player, int teamRet )
{
}

void GetPlayerTrain( Player player, int* train )
{
}

void GetPlayerVehicle( Player player, Vehicle* vehicleRet )
{
}

void SetPlayerVehicle( Player player, Vehicle vehicle )
{
}

void GetPlayerVehicleSeat( Player player, int* vehicleSeat )
{
}

void GetPlayerVelocity( Player player, Vector3* velocityRet )
{
}

void GetPlayerVirtualWorld( Player player, int* worldRet )
{
}

void SetPlayerVirtualWorld( Player player, int world )
{
}

void GetPlayerWantedLevel( Player player, int* wantedLevel )
{
}

void SetPlayerWantedLevel( Player player, int wantedLevel )
{
}

void GetPlayerWeapon( Player player, int* weaponRet )
{
}

void GetPlayerWeaponAmmo( Player player, int* weaponAmmo )
{
}

void GetPlayerWeaponState( Player player, int* weaponState )
{
}

void LoadModule( const char* moduleName )
{
}

void LoadScript( const char* scriptName )
{
}

void UnloadScript( const char* scriptName )
{
}

void FindHashTable( const char* name, HashTable* hashRet )
{
}

void CreateHashTable( const char* name, HashTable* hashRet )
{
}

void HashAdd( HashTable table, char* name, char* value )
{
}

void HashClose( HashTable table )
{
}

void HashDec( HashTable table, char* data, int value )
{
}

void HashDel( HashTable table, char* entry )
{
}

void HashGet( HashTable table, char* data, char* valueRet )
{
}

void HashInc( HashTable table, char* data, int value )
{
}

void HashLoad( HashTable table, char* location )
{
}

void HashSave( HashTable table, char* location )
{
}

void GetGamemodeName( char* nameRet )
{
}

void GetMapName( char* mapRet )
{
}

void GetMaxPlayers( int* ret )
{
}

void GetMTUSize( int* ret )
{
}

void GetPassword( char* ret )
{
}

void GetPlayers( int* ret )
{
}

void GetPort( int* port )
{
}

void GetServerName( char* ret )
{
}

void SetGamemodeName( char* name )
{
}

void SetMapName( char* name )
{
}

void SetMaxPlayers( int limit )
{
}

void SetPassword( char* password )
{
}

void SetPort( int port )
{
}

void SetServerName( char* name )
{
}

void SetServerRule( char* ruleName, char* ruleValue )
{
}

void FindSound( char* name, Sound* soundRet )
{
}

void FindSoundByID( int id, Sound* soundRet )
{
}

void PlayFrontEndSound( Player player, int sound )
{
}

void PlayFrontEndTrack( Player player, int sound )
{
}

void PlaySuspectLastSeen( Player player, Vector3* pos )
{
}

void CloseSound( Sound sound, Player player )
{
}

void OpenSound( Sound sound, Player player )
{
}

void PlaySound( Sound sound, Player player )
{
}

void PauseSound( Sound sound, Player player )
{
}

void StopSound( Sound sound, Player player )
{
}

void AddSpawnClass(
   int skin,
   int team,
   Vector3* pos,
   float angle,
   int color,
   int spawnScreen,
   SpawnClass* ret
)
{
}

void FindSpawnClass( int id, SpawnClass* ret )
{
}

void GetSpawnClassCount( int* ret )
{
}

void SetSpawnClassAngle( SpawnClass spawn, float angle )
{
}

void GetSpawnClassAngle( SpawnClass spawn, float* angle )
{
}

void GetSpawnClassColour( SpawnClass spawn, int* color )
{
}

void SetSpawnClassColour( SpawnClass spawn, int color )
{
}

void GetSpawnClassWeapon( SpawnClass spawn, int slot, int* weapon )
{
}

void GetSpawnClassWeaponAmmo( SpawnClass spawn, int slot, int* ammo )
{
}

void GetSpawnClassID ( SpawnClass spawn, int* idRet )
{
}

void GetSpawnClassPos( SpawnClass spawn, Vector3* posRet )
{
}

void SetSpawnClassPos( SpawnClass spawn, Vector3* pos )
{
}

void RemoveSpawnClassWeapon( SpawnClass spawn, int slot )
{
}

void AddSpawnClassWeapon( SpawnClass spawn, int weapon, int ammo, int slot )
{
}

void GetSpawnClassSkin( SpawnClass spawn, int* skin )
{
}

void SetSpawnClassSkin( SpawnClass spawn, int skin )
{
}

void GetSpawnClassSpawnScreen( SpawnClass spawn, int* screen )
{
}

void SetSpawnClassSpawnScreen( SpawnClass spawn, int screen )
{
}

void SetSpawnClassTeam( SpawnClass spawn, int team )
{
}

void GetSpawnClassTeam( SpawnClass spawn, int* team )
{
}

void CreateClientSphere( Vector3* pos, float radius, Player plr, Colour col, Sphere* sphereRet )
{
}

void CreateSphere( Vector3* pos, float radius, Colour col, Sphere* sphereRet )
{
}

void FindSphere( int id, Sphere* sphereRet )
{
}

void FindClientSphere( int id, Player plr, Sphere* sphereRet )
{
}

void GetSphereCount( int* count )
{
}

void GetClientSphereCount( Player plr, int* count )
{
}

void GetSphereColour( Sphere sphere, Colour* colour )
{
}

void SetSphereColour( Sphere sphere, Colour colour )
{
}

void GetSphereID( Sphere sphere, int* id )
{
}

void GetSpherePos( Sphere sphere, Vector3* pos )
{
}

void SetSpherePos( Sphere sphere, Vector3* pos )
{
}

void GetSphereRadius( Sphere sphere, float* radius )
{
}

void SetSphereRadius( Sphere sphere, float radius )
{
}

void RemoveSphere( Sphere sphere )
{
}

void GetSphereType( Sphere sphere, int* type )
{
}

void SetSphereType( Sphere sphere, int type )
{
}

void SetSphereVirtualWorld( Sphere sphere, int vWorld )
{
}

void GetSphereVirtualWorld( Sphere sphere, int* ret )
{
}

void GetDistance( Vector3* v1, Vector3* v2, float* ret )
{
}

void GetDistance2D( Vector2* v1, Vector2* v2, float* ret)
{
}

void GetTickCount( int* ret )
{
}

void IsNum( char* string, int* ret )
{
}

void GetWeaponIDFromName( char* weapon, int* ret )
{
}

void GetWeaponName( int weapon, char* ret )
{
}

void CreateVehicle( int model, Vector3* pos, float angle, int col1, int col2, Vehicle* ret )
{
}

void FindVehicle( int id, Vehicle* ret )
{
}

void GetClosestVehicle( Player plr, Vehicle* ret )
{
}

void GetVehicleCount( int* ret )
{
}

void GetVehicleIDFromName( char* name, int* ret )
{
}

void GetVehicleNameFromModel( int model, char* ret )
{
}

void GetVehicleNameFromVehicle( Vehicle vehicle, char* ret )
{
}

void GetVehicleAlpha( Vehicle vehicle, int* ret )
{
}

void SetVehicleAlpha( Vehicle vehicle, int alpha )
{
}

void GetVehicleAngle( Vehicle vehicle, float* ret )
{
}

void SetVehicleAngle( Vehicle vehicle, float angle )
{
}

void GetVehicleColour1( Vehicle vehicle, int* ret )
{
}

void GetVehicleColour2( Vehicle vehicle, int* ret )
{
}

void SetVehicleColour1( Vehicle vehicle, int col )
{
}

void SetVehicleColour2( Vehicle vehicle, int col )
{
}

void GetVehicleDriver( Vehicle vehicle, Player* ret )
{
}

void GetVehicleEngineDamage( Vehicle vehicle, int* ret )
{
}

void SetVehicleEngineDamage( Vehicle vehicle, int damage )
{
}

void ExplodeVehicle( Vehicle vehicle, Player responsible )
{
}

void FixVehicle( Vehicle vehicle )
{
}

void GetVehicleAddon( Vehicle vehicle, int* addonRet )
{
}

void GetVehiclePassenger( Vehicle vehicle, int seat, Player* ret )
{
}

void GetVehicleWheelStatus( Vehicle vehicle, int wheel, int* statusRet )
{
}

void GetVehicleHealth( Vehicle vehicle, float* healthRet )
{
}

void GetVehicleID( Vehicle vehicle, int* vehID )
{
}

void GetVehicleIdleRespawnTime( Vehicle vehicle, int* respawnSecs )
{
}

void SetVehicleIdleRespawnTime( Vehicle vehicle, int respawnSecs )
{
}

void GetVehicleIdleTime( Vehicle vehicle, int* idleMs )
{
}

void GetVehicleLightState( Vehicle vehicle, int* state )
{
}

void SetVehicleLightState( Vehicle vehicle, int state )
{
}

void GetVehicleLocked( Vehicle vehicle, int* isLocked )
{
}

void SetVehicleLocked( Vehicle vehicle, int isLocked )
{
}

void GetVehicleModel( Vehicle vehicle, int* modelRet )
{
}

void GetVehicleOneTime( Vehicle vehicle, int* isOneTime )
{
}

void SetVehicleOneTime( Vehicle vehicle, int isOneTime )
{
}

void GetVehiclePassengerCount( Vehicle vehicle, int* ret )
{
}

void GetVehiclePos( Vehicle vehicle, Vector3* pos )
{
}

void SetVehiclePos( Vehicle vehicle, Vector3* pos )
{
}

void RemoveVehicle( Vehicle vehicle )
{
}

void RespawnVehicle( Vehicle vehicle )
{
}

void GetVehicleRespawnTime( Vehicle vehicle, int* ret )
{
}

void SetVehicleRespawnTime( Vehicle vehicle, int seconds)
{
}

void GetVehicleRGBColour1( Vehicle vehicle, Colour* ret )
{
}

void SetVehicleRGBColour1( Vehicle vehicle, Colour col )
{
}

void GetVehicleRGBColour2( Vehicle vehicle, Colour* ret )
{
}

void SetVehicleRGBColour2( Vehicle vehicle, Colour col )
{
}

void SetVehicleWheelStatus( Vehicle vehicle, int wheel, int status )
{
}

void GetVehicleSpawnAngle( Vehicle vehicle, float* ret )
{
}

void SetVehicleSpawnAngle( Vehicle vehicle, float angle )
{
}

void GetVehicleSpawnPos( Vehicle vehicle, Vector3* ret )
{
}

void SetVehicleSpawnPos( Vehicle vehicle, Vector3* pos )
{
}

void SetVehicleAddon( Vehicle vehicle, int addon )
{
}

void SetVehicleEngineState( Vehicle vehicle, int status )
{
}

void SetVehicleRadioStation( Vehicle vehicle, int channel )
{
}

void GetVehicleSiren( Vehicle vehicle, int* ret )
{
}

void SetVehicleSiren( Vehicle vehicle, int status )
{
}

void GetVehicleSirenLight( Vehicle vehicle, int* ret )
{
}

void SetVehicleSirenLight( Vehicle vehicle, int status )
{
}

void GetVehicleTaxiLight( Vehicle vehicle, int* ret )
{
}

void SetVehicleTaxiLight( Vehicle vehicle, int status )
{
}

void GetVehicleWrecked( Vehicle vehicle, int* ret )
{
}